package com.dkd.day20250712;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main12 {
    public static void main(String[] args) {
//给定一个 m x n 的矩阵，由若干字符 ‘X’ 和 ‘O’构成，’X’表示该处已被占据，’O’表示该处空闲，请找到最大的单入口空闲区域。
//
//解释：
//
//空闲区域是由连通的’O’组成的区域，位于边界的’O’可以构成入口，
//
//单入口空闲区域即有且只有一个位于边界的’O’作为入口的由连通的’O’组成的区域。
//如果两个元素在水平或垂直方向相邻，则称它们是“连通”的。
//
//输入描述
//第一行输入为两个数字，第一个数字为行数m，第二个数字为列数n，两个数字以空格分隔，1<=m,n<=200。
//
//剩余各行为矩阵各行元素，元素为‘X’或‘O’，各元素间以空格分隔。
//
//输出描述
//若有唯一符合要求的最大单入口空闲区域，输出三个数字
//
//第一个数字为入口行坐标（0~m-1）
//第二个数字为入口列坐标（0~n-1）
//第三个数字为区域大小
//三个数字以空格分隔；
//
//若有多个符合要求，则输出区域大小最大的，若多个符合要求的单入口区域的区域大小相同，则此时只需要输出区域大小，不需要输出入口坐标。
//
//若没有，输出NULL。

        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        String[][] arr = new String[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.next();
            }
        }
        solve(arr,m,n);


    }



    public static void solve(String[][] arr,int m ,int n){
        int max = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (arr[i][j].equals("O")) {
                    dfs(arr,i,j);
                    if(count == 1){
                        if(max < area){
                            max = area;
                            if(list.size() >= 2){
                                list.remove(0);
                            }
                        }
                    }else{
                        for(int k = 0; k < count; k++){
                            list.remove(list.size()-1);
                        }
                    }
                    count = 0;
                    area = 0 ;
                }
            }
        }
        if(max ==0){
            System.out.println("NULL");
        }else{
            //判断list
            if(list.size() == 1){
                System.out.print(list.get(0)[0]);
                System.out.print(" ");
                System.out.print(list.get(0)[1]);
                System.out.print(" ");
                System.out.print(max);
            }else{
                System.out.println(max);
            }
        }
    }

    //向4个方向判断
    //传递边界0的数量
    static int area = 0;
    static int count = 0;
  //  static int [][] off={{1,0},{-1,0},{0,-1},{0,1}};
    static List<int[]> list = new ArrayList<int[]>();

    public static void dfs(String[][] arr,int i ,int j){
        //盘点是否为o,o则继续判断，不是则返回

        area++;
        arr[i][j] = "X";
        if(i ==0 || j ==0 || i==arr.length-1 || j==arr[0].length-1){
            count++;
            int[] ans={i,j,0};
            list.add(ans);
        }
        //向四方遍历
/*        for (int i = 0; i < off.length; i++) {
            m = m + off[i][0];
            n = n + off[i][1];
            //判断是否越界
            if(m>=0 && n>=0 && m<arr.length && n<arr[0].length && arr[m][n].equals("O")){
                dfs(arr,m,n);
            }
        }*/
        if(i-1>=0 && arr[i-1][j].equals("O")){
            dfs(arr,i-1,j);
        }
        if(j-1>=0 && arr[i][j-1].equals("O")){
            dfs(arr,i,j-1);
        }
        if(i+1<arr.length && arr[i+1][j].equals("O")){
            dfs(arr,i+1,j);
        }
        if(j+1<arr[0].length && arr[i][j+1].equals("O")){
            dfs(arr,i,j+1);
        }



    }
}
